﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Generic.Contract;
using Generic.Data.Manager;
using Contract.Business.Entity;
using Contract.Business.Filter;
using DataEntity;

namespace Contract.Data.Manager
{
    //Criado por : Gustavo
    //Data       : 10/25/2011 12:04:42 AM
    public class DMCliente : DMGeneric<BECliente, FECliente>
    {
        databaseDataContext dc;

        #region Override

        public override BECliente Salvar(BECliente entidade)
        {
            try
            {
                if (entidade.Codigo.Equals(0))
                    entidade.Codigo = Incluir(entidade);
                else
                    Alterar(entidade);

                return entidade;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public override void Excluir(BECliente entidade)
        {
            try
            {
                using (dc = new databaseDataContext())
                {
                    DECliente de = dc.DEClientes.Single(q => q.Codigo.Equals(entidade.Codigo));

                    dc.DEClientes.DeleteOnSubmit(de);
                    dc.SubmitChanges();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        public override BECliente ObterEntidade(int codigo)
        {
            try
            {
                DECliente obj = null;
                using (dc = new databaseDataContext())
                {
                    obj = dc.DEClientes.Single(q => q.Codigo.Equals(codigo));
                    return obj.ConvertToBE(1);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        public override List<BECliente> ObterTodos(FECliente filter)
        {
            try
            {
                List<DECliente> deCliente = null;
                using (dc = new databaseDataContext())
                {

                    var q = from e in dc.DEClientes
                            where
                            (
                                (((filter.Nome != null)
                                && (e.Nome.Contains(filter.Nome))) || (filter.Nome == null)) &&

                                (((filter.Bloqueado != null)
                                && (e.Bloqueado == filter.Bloqueado)) || (filter.Bloqueado == null)) &&

                                ((filter.TelResidencial != null)
                                && ((e.TelResidencial.Contains(filter.TelResidencial) || e.TelComercial.Contains(filter.TelResidencial) || e.TelResidencial2.Contains(filter.TelResidencial))) 
                                        || (filter.TelResidencial == null)) &&

                                (((filter.Email != null)
                                && (e.Email.Contains(filter.Email))) || (filter.Email == null)) &&

                                (((filter.NascimentoMax != null)
                                && (e.Nascimento <= filter.NascimentoMax)) || (filter.NascimentoMax == null)) &&

                                (((filter.NascimentoMin != null)
                                && (e.Nascimento >= filter.NascimentoMin)) || (filter.NascimentoMin == null)) &&

                                (((filter.CodigoRegiaoEntrega != null)
                                && (e.CodigoRegiaoEntrega == filter.CodigoRegiaoEntrega)) || (filter.CodigoRegiaoEntrega == null))
                            )
                            select e;

                    deCliente = q.ToList();

                    List<BECliente> retorno = new List<BECliente>();

                    foreach (DECliente de in deCliente)
                        retorno.Add(de.ConvertToBE(1));

                    return retorno;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        #endregion

        #region Métodos Auxiliares

        public void IncrementarContadorPizza(int Codigo)
        {
            try
            {
                using (dc = new databaseDataContext())
                {
                    DECliente de = dc.DEClientes.Single(q =>q.Codigo.Equals(Codigo));

                    de.NumeroContadorPizza++;
                    dc.SubmitChanges();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        private int Incluir(BECliente entidade)
        {
            try
            {
                using (dc = new databaseDataContext())
                {
                    DECliente de = new DECliente();
                    de.ConvertFromBE(entidade);

                    dc.DEClientes.InsertOnSubmit(de);

                    dc.SubmitChanges();

                    return de.Codigo;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        private void Alterar(BECliente entidade)
        {
            try
            {
                using (dc = new databaseDataContext())
                {
                    DECliente de = dc.DEClientes.Single(q => q.Codigo.Equals(entidade.Codigo));

                    de.Nome = entidade.Nome;
                    de.Bloqueado = entidade.Bloqueado;
                    de.Endereco = entidade.Endereco;
                    de.Bairro = entidade.Bairro;
                    de.Cidade = entidade.Cidade;
                    de.UF = entidade.UF;
                    if (!String.IsNullOrEmpty(entidade.CEP))
                        de.CEP = entidade.CEP.Replace("-", "");
                    de.PontoReferencia = entidade.PontoReferencia;
                    if (!String.IsNullOrEmpty(entidade.TelResidencial))
                        de.TelResidencial = entidade.TelResidencial.Replace("-", "");
                    if (!String.IsNullOrEmpty(entidade.TelResidencial2))
                        de.TelResidencial2 = entidade.TelResidencial2.Replace("-", "");
                    if (!String.IsNullOrEmpty(entidade.TelComercial))
                        de.TelComercial = entidade.TelComercial.Replace("-", "");
                    de.Email = entidade.Email;
                    de.Nascimento = entidade.Nascimento;
                    de.Observacao = entidade.Observacao;
                    de.CodigoRegiaoEntrega = entidade.CodigoRegiaoEntrega;
                    de.DesejaReceberEmails = entidade.DesejaReceberEmails;
                    de.NumeroContadorPizza = entidade.NumeroContadorPizza;

                    dc.SubmitChanges();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        public List<BECliente> BuscarClienteVenda(string telefone)
        {
            try
            {
                telefone = telefone.Replace("-", "");

                using (dc = new databaseDataContext())
                {
                    var q = from e in dc.DEClientes
                            where
                            (
                               telefone.Equals(e.TelResidencial) ||
                               telefone.Equals(e.TelResidencial2) ||
                               telefone.Equals(e.TelComercial)
                            )
                            select e;

                    List<DECliente> deCliente = q.ToList();

                    List<BECliente> retorno = new List<BECliente>();

                    foreach (DECliente de in deCliente)
                        retorno.Add(de.ConvertToBE(1));

                    return retorno;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        #endregion
    }
}
